package cn.edu.scut.hsrc.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import cn.edu.scut.hsrc.bean.Pair;

/**
 * 字符串工具类
 * @file StringUtil.java
 * @author feiyu
 *
 */

public class StringUtil {
	
	/**
	 * 获取字符串str中在给定模式串patterns前的子串
	 * @param str
	 * @param patterns
	 * @return
	 */
	public static String getPreString(String str,String ...patterns)
	{
		String cursum = str;
		int size = patterns.length;
		int[] pos = new int[size];
		for (int i = size - 1; i >= 0; i--) {
			pos[i] = cursum.indexOf(patterns[i]);
		}
		int min = getMin(pos, 0);
		
		if (min > 0) {
			cursum = cursum.substring(0, min);
		}
		return cursum;
	}
	/**
	 * 获取给定数组array中给定value的最小上界
	 * @param array	数组
	 * @param value	返回的上界需要大于value
	 * @return	 	返回value的上界，如果没有上界就返回-1
	 */
	private static int getMin(int [] array,int value)
	{
		int min = Integer.MAX_VALUE;
		for (int temp : array) {
			if(temp < min && temp > value)
				min = temp;
		}
		if(min == Integer.MAX_VALUE)
			return -1;
		return min;
	}
	
	
	/**
	 * 把字符串str中的空格用分隔符divide代替
	 * @param str		源字符串
	 * @param divide    分隔符
	 * @return
	 */
	public static String replaceWhiteSpace(String str,String divide)// 
	{
		return str.replaceAll(" +", divide);
	}
	
	/**
	 * 去除字符串str的所有空格
	 * @param str 待处理的短语或句、段。
	 */
	public static String removeWhiteSpace(String str) {
		return str.replace(" ", "");
	}
	
	/**
	 * 保留中文字词
	 * @param str  待处理的短语或句、段。
	 * @return
	 */
	public static String remainChinese(String str)
	{
		String result = "";
		String regEx = "[\\u4e00-\\u9fa5]";

		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(str);

		while (m.find()) {
			result += m.group(0);
		}
		return result;
	}
	
	/**
	 * 判断一个字符串是否全部都为中文（这个函数有缺陷，谨慎使用）
	 * @param str
	 * @return
	 */
	public static boolean isAllChinese(String str) {
		String pstr = "[\u4e00-\u9fa5]{2}+";
		Pattern p = Pattern.compile(pstr);
		Matcher m = p.matcher(str);
		return m.find();
	}
	
	/**
	 * 把字符串string用分隔符SegUtil.SPLITS分开
	 * @param string	
	 * @return
	 */
	public static List<String> splitByPos(String string) {
		List<String> results = new ArrayList<String>();
		StringTokenizer tokenizer = new StringTokenizer(string, SegUtil.SPLITS_STRING);
		while (tokenizer.hasMoreTokens()) {
			results.add(tokenizer.nextToken());
		}
		return results;
	}
	
	/**
	 * 把字符串string用多个自定义的子字符串patterns分割开来，注意这个函数有缺陷，
	 * patterns不能出现java正则表达式中转义字符，如果出现了，就有可能出错，最好都只是普通的文字子串
	 * @param string
	 * @param patterns
	 * @param returnDelims	true表示patterns里面子字符串也返回，false表示patterns里面的子字符串仅作为分隔符
	 * @return
	 */
	public static List<Pair<String, Boolean>> splitByPatterns(String string,List<String> patterns,boolean returnDelims)
	{
		List<Pair<String, Boolean>> results = new ArrayList<Pair<String, Boolean>>();
		if(patterns == null || patterns.size() == 0)
		{
			results.add(new Pair<String, Boolean>(string,false));
		}else {
			//利用正则表达式进行分割
			String regex = "";
			for (String patt : patterns) {
				if(!patt.equals(""))
					regex += "|"+patt;
			}
			regex = regex.substring(1);
			Pattern pattern = Pattern.compile(regex);
			Matcher matcher = pattern.matcher(string);
			StringBuffer buffer = new StringBuffer();
			//如果做为分割的字符串也要返回
			if(returnDelims)
			{
				while (matcher.find()) {
					matcher.appendReplacement(buffer, "");
					if(buffer.length()>0)
						results.add(new Pair<String, Boolean>(buffer.toString(),false));
					results.add(new Pair<String, Boolean>(matcher.group(),true));
					buffer.delete(0, buffer.length());
				}
				matcher.appendTail(buffer);
				if(buffer.length()>0)
					results.add(new Pair<String, Boolean>(buffer.toString(),false));
			}else {//如果做为分割的字符串只是作为分隔符
				while (matcher.find()) {
					matcher.appendReplacement(buffer, "");
					if(buffer.length()>0)
						results.add(new Pair<String, Boolean>(buffer.toString(),false));
					buffer.delete(0, buffer.length());
				}
				matcher.appendTail(buffer);
				if(buffer.length()>0)
					results.add(new Pair<String, Boolean>(buffer.toString(),false));
			}
		}
		return results;
	}
	
	/**
	 * 把字符串string用多个自定义的子字符串patterns分割开来，注意这个函数有缺陷，
	 * patterns不能出现java正则表达式中转义字符，如果出现了，就有可能出错，最好都只是普通的文字子串
	 * @param string
	 * @param patterns
	 * @param returnDelims	true表示patterns里面子字符串也返回，false表示patterns里面的子字符串仅作为分隔符
	 * @return 返回<字符串,是否是模式串标识>对的集合
	 */
	public static List<Pair<String, Boolean>> splitByPatterns(String string,String[] patterns,boolean returnDelims)
	{
		return splitByPatterns(string, Arrays.asList(patterns), returnDelims);
	}
	
	public static void main(String[] args) {
		/*String text = "StringTokenizer 的实例有两种行为方式，这取决于它在创建时使用的 returnDelims 标志的实例值是 true 还是 false实例";
		//List<String> list = splitByPos(text);
		List<Pair<String, Boolean>> list = splitByPatterns(text, new String[]{"实例","创建"},true);
		for (Pair<String, Boolean> string : list) {
			System.out.println(string);
		}*/
		String chinese = "中华人民共和国";
		System.out.println(isAllChinese(chinese));
	}
}
